package com.sbtr.util;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * @Author maojianping
 * @Date 2023/3/31 14:13
 * @Version 1.0
 * 用途：数据处理工具类
 * */
public class ArrayHelper {

    // 判断数组是否为空或null
    public static boolean isNullOrEmpty(Object[] arr) {
        return arr == null || arr.length == 0;
    }

      /**
   * 将数组转换为 List。
   *
   * @param array 要转换的数组。
   * @param <T> 数组类型。
   * @return 数组转换后的 List。
   */
  public static <T> List<T> arrayToList(T[] array) {
    return new ArrayList<>(Arrays.asList(array));
  }

  /**
   * 将 List 转换为数组。
   *
   * @param list 要转换的 List。
   * @param clazz 数组类型。
   * @param <T> 数组类型。
   * @return List 转换后的数组。
   */
  public static <T> T[] listToArray(List<T> list, Class<T> clazz) {
    return list.toArray((T[]) Array.newInstance(clazz, list.size()));
  }

  /**
   * 将字符串转换为数组。
   *
   * @param str 要转换的字符串。
   * @param separator 分隔符。
   * @return 字符串转换后的数组。
   */
  public static String[] stringToArray(String str, String separator) {
    return str.split(separator);
  }

    /**
   * 将数组转换为字符串。
   *
   * @param array 要转换的数组。
   * @param separator 分隔符。
   * @return 数组转换后的字符串。
   */
  public static String arrayToString(Object[] array, String separator) {
    return Arrays.toString(array).replace("[", "").replace("]", "").replace(",", separator);
  }

    /**
   * 复制数组。
   *
   * @param array 要复制的数组。
   * @param <T> 数组类型。
   * @return 复制后的数组。
   */
  public static <T> T[] copyArray(T[] array) {
    return Arrays.copyOf(array, array.length);
  }
  
  
    /**
   * 对数组进行排序。
   *
   * @param array 要排序的数组。
   * @param <T> 数组类型。
   * @return 排序后的数组。
   */
  public static <T extends Comparable<T>> T[] sortArray(T[] array) {
    Arrays.sort(array);
    return array;
  }

   /**
     * 在数组中查找元素
     * @param arr 数组
     * @param target 要查找的元素
     * @return 元素的索引，如果不存在则返回-1
     */
    public static int indexOf(int[] arr, int target) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == target) {
                return i;
            }
        }
        return -1;
    }
    /**
     * 反转数组
     * @param arr 数组
     */
    public static void reverse(int[] arr) {
        if (arr == null || arr.length == 0) {
            return;
        }
        int i = 0;
        int j = arr.length - 1;
        while (i < j) {
            int tmp = arr[i];
            arr[i] = arr[j];
            arr[j] = tmp;
            i++;
            j--;
        }
    }

    // 将数组转换为逗号分隔的字符串
    public static String arrayToCsvString(Object[] arr) {
        StringBuilder sb = new StringBuilder();
        for (Object obj : arr)
            sb.append(obj.toString()).append(",");

        if (sb.length() > 0)
            sb.deleteCharAt(sb.length() - 1);

        return sb.toString();
    }

     /**
     * 将数组转换成列表
     * @param arr 数组
     * @return 列表
     */
    public static List<Integer> arrayToList(int[] arr) {
        if (arr == null)
            return null;

        List<Integer> list = new ArrayList<>();
        for (int i : arr) {
            list.add(i);
        }
        return list;
    }
    /**
     * 将列表转换成数组
     * @param list 列表
     * @return 数组
     */
    public static int[] listToArray(List<Integer> list) {
        if (list == null) {
            return null;
        }
        int len = list.size();
        int[] arr = new int[len];
        for (int i = 0; i < len; i++) {
            arr[i] = list.get(i);
        }
        return arr;
    }

    /**
     * 将字符串数组转换为数值类型数组
     * @param strArr 字符串数组
     * @param clazz 数值类型对象
     * @return 数值类型数组
     */
    public static <T extends Number> T[] convertStrArrToNumberArr(String[] strArr, Class<T> clazz) {
        if (strArr == null || strArr.length == 0) {
            return null;
        }
        T[] numArr = (T[]) Array.newInstance(clazz, strArr.length);
        for (int i = 0; i < strArr.length; i++) {
            if (clazz == Integer.class) {
                numArr[i] = (T) Integer.valueOf(strArr[i]);
            } else if (clazz == Double.class) {
                numArr[i] = (T) Double.valueOf(strArr[i]);
            } else if (clazz == Float.class) {
                numArr[i] = (T) Float.valueOf(strArr[i]);
            } else if (clazz == Long.class) {
                numArr[i] = (T) Long.valueOf(strArr[i]);
            } else if (clazz == Short.class) {
                numArr[i] = (T) Short.valueOf(strArr[i]);
            } else if (clazz == Byte.class) {
                numArr[i] = (T) Byte.valueOf(strArr[i]);
            }
        }
        return numArr;
    }

    /**
     * 将数值类型数组转换为字符串类型数组
     * @param numArr 数值类型数组
     * @return 字符串类型数组
     */
    public static String[] convertNumberArrToStrArr(Number[] numArr) {
        if (numArr == null || numArr.length == 0) {
            return null;
        }
        String[] strArr = new String[numArr.length];
        for (int i = 0; i < numArr.length; i++) {
            strArr[i] = numArr[i].toString();
        }
        return strArr;
    }

}
